#include<cassert>
#include<algorithm>
#include<typeinfo>

// 通用类型类
class Any
{
private:
    class holder
    {
    public:
        virtual ~holder() {}
        virtual const std::type_info& type() = 0;
        virtual holder *clone() = 0;
    };
    template <class T>
    class placeholder : public holder
    {
    public:
        placeholder(const T &val) : _val(val) {}
        virtual const std::type_info& type() { return typeid(T); }
        virtual holder *clone() { return new placeholder(_val); }
        ~placeholder() {}
        T _val;
    };
    holder *_content;

public:
    Any():_content(nullptr){}
    template <class T>
    Any(const T &val):_content(new placeholder<T>(val)){}
    Any(const Any &other):_content(other._content ? other._content->clone():nullptr) {}
    ~Any() {delete _content;}
    Any &swap(Any &other){
        std::swap(_content,other._content);
        return *this;
    }

    template <class T>
    T *get() {
        assert(typeid(T) == _content->type());
        return &((placeholder<T> *)_content)->_val;
    }

    template <class T>
    Any &operator=(const T &val) {
        //使用临时对象进行交换
        Any(val).swap(*this);
        return *this;
    }

    Any &operator=(const Any &other) {
        Any(other).swap(*this);
        return *this;
    }
};